// Code generated by MockGen. DO NOT EDIT.
// Source: types/upstream.go

// Package mock is a generated GoMock package.
package mock

import (
	context "context"
	net "net"
	reflect "reflect"
	time "time"

	gomock "github.com/golang/mock/gomock"
	api "mosn.io/api"
	v2 "mosn.io/mosn/pkg/config/v2"
	types "mosn.io/mosn/pkg/types"
)

// MockClusterManager is a mock of ClusterManager interface.
type MockClusterManager struct {
	ctrl     *gomock.Controller
	recorder *MockClusterManagerMockRecorder
}

// MockClusterManagerMockRecorder is the mock recorder for MockClusterManager.
type MockClusterManagerMockRecorder struct {
	mock *MockClusterManager
}

// NewMockClusterManager creates a new mock instance.
func NewMockClusterManager(ctrl *gomock.Controller) *MockClusterManager {
	mock := &MockClusterManager{ctrl: ctrl}
	mock.recorder = &MockClusterManagerMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockClusterManager) EXPECT() *MockClusterManagerMockRecorder {
	return m.recorder
}

// AddClusterHealthCheckCallbacks mocks base method.
func (m *MockClusterManager) AddClusterHealthCheckCallbacks(name string, cb types.HealthCheckCb) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddClusterHealthCheckCallbacks", name, cb)
	ret0, _ := ret[0].(error)
	return ret0
}

// AddClusterHealthCheckCallbacks indicates an expected call of AddClusterHealthCheckCallbacks.
func (mr *MockClusterManagerMockRecorder) AddClusterHealthCheckCallbacks(name, cb interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddClusterHealthCheckCallbacks", reflect.TypeOf((*MockClusterManager)(nil).AddClusterHealthCheckCallbacks), name, cb)
}

// AddOrUpdateClusterAndHost mocks base method.
func (m *MockClusterManager) AddOrUpdateClusterAndHost(cluster v2.Cluster, hosts []v2.Host) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddOrUpdateClusterAndHost", cluster, hosts)
	ret0, _ := ret[0].(error)
	return ret0
}

// AddOrUpdateClusterAndHost indicates an expected call of AddOrUpdateClusterAndHost.
func (mr *MockClusterManagerMockRecorder) AddOrUpdateClusterAndHost(cluster, hosts interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddOrUpdateClusterAndHost", reflect.TypeOf((*MockClusterManager)(nil).AddOrUpdateClusterAndHost), cluster, hosts)
}

// AddOrUpdatePrimaryCluster mocks base method.
func (m *MockClusterManager) AddOrUpdatePrimaryCluster(cluster v2.Cluster) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddOrUpdatePrimaryCluster", cluster)
	ret0, _ := ret[0].(error)
	return ret0
}

// AddOrUpdatePrimaryCluster indicates an expected call of AddOrUpdatePrimaryCluster.
func (mr *MockClusterManagerMockRecorder) AddOrUpdatePrimaryCluster(cluster interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddOrUpdatePrimaryCluster", reflect.TypeOf((*MockClusterManager)(nil).AddOrUpdatePrimaryCluster), cluster)
}

// AppendClusterHosts mocks base method.
func (m *MockClusterManager) AppendClusterHosts(clusterName string, hostConfigs []v2.Host) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AppendClusterHosts", clusterName, hostConfigs)
	ret0, _ := ret[0].(error)
	return ret0
}

// AppendClusterHosts indicates an expected call of AppendClusterHosts.
func (mr *MockClusterManagerMockRecorder) AppendClusterHosts(clusterName, hostConfigs interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AppendClusterHosts", reflect.TypeOf((*MockClusterManager)(nil).AppendClusterHosts), clusterName, hostConfigs)
}

// ClusterExist mocks base method.
func (m *MockClusterManager) ClusterExist(clusterName string) bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ClusterExist", clusterName)
	ret0, _ := ret[0].(bool)
	return ret0
}

// ClusterExist indicates an expected call of ClusterExist.
func (mr *MockClusterManagerMockRecorder) ClusterExist(clusterName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterExist", reflect.TypeOf((*MockClusterManager)(nil).ClusterExist), clusterName)
}

// ConnPoolForCluster mocks base method.
func (m *MockClusterManager) ConnPoolForCluster(balancerContext types.LoadBalancerContext, snapshot types.ClusterSnapshot, protocol api.ProtocolName) (types.ConnectionPool, types.Host) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ConnPoolForCluster", balancerContext, snapshot, protocol)
	ret0, _ := ret[0].(types.ConnectionPool)
	ret1, _ := ret[1].(types.Host)
	return ret0, ret1
}

// ConnPoolForCluster indicates an expected call of ConnPoolForCluster.
func (mr *MockClusterManagerMockRecorder) ConnPoolForCluster(balancerContext, snapshot, protocol interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConnPoolForCluster", reflect.TypeOf((*MockClusterManager)(nil).ConnPoolForCluster), balancerContext, snapshot, protocol)
}

// Destroy mocks base method.
func (m *MockClusterManager) Destroy() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Destroy")
}

// Destroy indicates an expected call of Destroy.
func (mr *MockClusterManagerMockRecorder) Destroy() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Destroy", reflect.TypeOf((*MockClusterManager)(nil).Destroy))
}

// GetClusterSnapshot mocks base method.
func (m *MockClusterManager) GetClusterSnapshot(context context.Context, cluster string) types.ClusterSnapshot {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetClusterSnapshot", context, cluster)
	ret0, _ := ret[0].(types.ClusterSnapshot)
	return ret0
}

// GetClusterSnapshot indicates an expected call of GetClusterSnapshot.
func (mr *MockClusterManagerMockRecorder) GetClusterSnapshot(context, cluster interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetClusterSnapshot", reflect.TypeOf((*MockClusterManager)(nil).GetClusterSnapshot), context, cluster)
}

// GetTLSManager mocks base method.
func (m *MockClusterManager) GetTLSManager() types.TLSClientContextManager {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTLSManager")
	ret0, _ := ret[0].(types.TLSClientContextManager)
	return ret0
}

// GetTLSManager indicates an expected call of GetTLSManager.
func (mr *MockClusterManagerMockRecorder) GetTLSManager() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTLSManager", reflect.TypeOf((*MockClusterManager)(nil).GetTLSManager))
}

// PutClusterSnapshot mocks base method.
func (m *MockClusterManager) PutClusterSnapshot(arg0 types.ClusterSnapshot) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "PutClusterSnapshot", arg0)
}

// PutClusterSnapshot indicates an expected call of PutClusterSnapshot.
func (mr *MockClusterManagerMockRecorder) PutClusterSnapshot(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutClusterSnapshot", reflect.TypeOf((*MockClusterManager)(nil).PutClusterSnapshot), arg0)
}

// RemoveClusterHosts mocks base method.
func (m *MockClusterManager) RemoveClusterHosts(clusterName string, hosts []string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RemoveClusterHosts", clusterName, hosts)
	ret0, _ := ret[0].(error)
	return ret0
}

// RemoveClusterHosts indicates an expected call of RemoveClusterHosts.
func (mr *MockClusterManagerMockRecorder) RemoveClusterHosts(clusterName, hosts interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveClusterHosts", reflect.TypeOf((*MockClusterManager)(nil).RemoveClusterHosts), clusterName, hosts)
}

// RemovePrimaryCluster mocks base method.
func (m *MockClusterManager) RemovePrimaryCluster(clusters ...string) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{}
	for _, a := range clusters {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RemovePrimaryCluster", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// RemovePrimaryCluster indicates an expected call of RemovePrimaryCluster.
func (mr *MockClusterManagerMockRecorder) RemovePrimaryCluster(clusters ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemovePrimaryCluster", reflect.TypeOf((*MockClusterManager)(nil).RemovePrimaryCluster), clusters...)
}

// ShutdownConnectionPool mocks base method.
func (m *MockClusterManager) ShutdownConnectionPool(proto types.ProtocolName, addr string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "ShutdownConnectionPool", proto, addr)
}

// ShutdownConnectionPool indicates an expected call of ShutdownConnectionPool.
func (mr *MockClusterManagerMockRecorder) ShutdownConnectionPool(proto, addr interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ShutdownConnectionPool", reflect.TypeOf((*MockClusterManager)(nil).ShutdownConnectionPool), proto, addr)
}

// TCPConnForCluster mocks base method.
func (m *MockClusterManager) TCPConnForCluster(balancerContext types.LoadBalancerContext, snapshot types.ClusterSnapshot) types.CreateConnectionData {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TCPConnForCluster", balancerContext, snapshot)
	ret0, _ := ret[0].(types.CreateConnectionData)
	return ret0
}

// TCPConnForCluster indicates an expected call of TCPConnForCluster.
func (mr *MockClusterManagerMockRecorder) TCPConnForCluster(balancerContext, snapshot interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TCPConnForCluster", reflect.TypeOf((*MockClusterManager)(nil).TCPConnForCluster), balancerContext, snapshot)
}

// UDPConnForCluster mocks base method.
func (m *MockClusterManager) UDPConnForCluster(balancerContext types.LoadBalancerContext, snapshot types.ClusterSnapshot) types.CreateConnectionData {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UDPConnForCluster", balancerContext, snapshot)
	ret0, _ := ret[0].(types.CreateConnectionData)
	return ret0
}

// UDPConnForCluster indicates an expected call of UDPConnForCluster.
func (mr *MockClusterManagerMockRecorder) UDPConnForCluster(balancerContext, snapshot interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UDPConnForCluster", reflect.TypeOf((*MockClusterManager)(nil).UDPConnForCluster), balancerContext, snapshot)
}

// UpdateCluster mocks base method.
func (m *MockClusterManager) UpdateCluster(cluster v2.Cluster, clusterHandler types.ClusterUpdateHandler) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateCluster", cluster, clusterHandler)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateCluster indicates an expected call of UpdateCluster.
func (mr *MockClusterManagerMockRecorder) UpdateCluster(cluster, clusterHandler interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateCluster", reflect.TypeOf((*MockClusterManager)(nil).UpdateCluster), cluster, clusterHandler)
}

// UpdateClusterHosts mocks base method.
func (m *MockClusterManager) UpdateClusterHosts(cluster string, hosts []v2.Host) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateClusterHosts", cluster, hosts)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateClusterHosts indicates an expected call of UpdateClusterHosts.
func (mr *MockClusterManagerMockRecorder) UpdateClusterHosts(cluster, hosts interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateClusterHosts", reflect.TypeOf((*MockClusterManager)(nil).UpdateClusterHosts), cluster, hosts)
}

// UpdateHosts mocks base method.
func (m *MockClusterManager) UpdateHosts(clusterName string, hostConfigs []v2.Host, hostHandler types.HostUpdateHandler) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateHosts", clusterName, hostConfigs, hostHandler)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateHosts indicates an expected call of UpdateHosts.
func (mr *MockClusterManagerMockRecorder) UpdateHosts(clusterName, hostConfigs, hostHandler interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateHosts", reflect.TypeOf((*MockClusterManager)(nil).UpdateHosts), clusterName, hostConfigs, hostHandler)
}

// UpdateTLSManager mocks base method.
func (m *MockClusterManager) UpdateTLSManager(arg0 *v2.TLSConfig) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "UpdateTLSManager", arg0)
}

// UpdateTLSManager indicates an expected call of UpdateTLSManager.
func (mr *MockClusterManagerMockRecorder) UpdateTLSManager(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTLSManager", reflect.TypeOf((*MockClusterManager)(nil).UpdateTLSManager), arg0)
}

// MockClusterSnapshot is a mock of ClusterSnapshot interface.
type MockClusterSnapshot struct {
	ctrl     *gomock.Controller
	recorder *MockClusterSnapshotMockRecorder
}

// MockClusterSnapshotMockRecorder is the mock recorder for MockClusterSnapshot.
type MockClusterSnapshotMockRecorder struct {
	mock *MockClusterSnapshot
}

// NewMockClusterSnapshot creates a new mock instance.
func NewMockClusterSnapshot(ctrl *gomock.Controller) *MockClusterSnapshot {
	mock := &MockClusterSnapshot{ctrl: ctrl}
	mock.recorder = &MockClusterSnapshotMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockClusterSnapshot) EXPECT() *MockClusterSnapshotMockRecorder {
	return m.recorder
}

// ClusterInfo mocks base method.
func (m *MockClusterSnapshot) ClusterInfo() types.ClusterInfo {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ClusterInfo")
	ret0, _ := ret[0].(types.ClusterInfo)
	return ret0
}

// ClusterInfo indicates an expected call of ClusterInfo.
func (mr *MockClusterSnapshotMockRecorder) ClusterInfo() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterInfo", reflect.TypeOf((*MockClusterSnapshot)(nil).ClusterInfo))
}

// HostNum mocks base method.
func (m *MockClusterSnapshot) HostNum(metadata api.MetadataMatchCriteria) int {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HostNum", metadata)
	ret0, _ := ret[0].(int)
	return ret0
}

// HostNum indicates an expected call of HostNum.
func (mr *MockClusterSnapshotMockRecorder) HostNum(metadata interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HostNum", reflect.TypeOf((*MockClusterSnapshot)(nil).HostNum), metadata)
}

// HostSet mocks base method.
func (m *MockClusterSnapshot) HostSet() types.HostSet {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HostSet")
	ret0, _ := ret[0].(types.HostSet)
	return ret0
}

// HostSet indicates an expected call of HostSet.
func (mr *MockClusterSnapshotMockRecorder) HostSet() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HostSet", reflect.TypeOf((*MockClusterSnapshot)(nil).HostSet))
}

// IsExistsHosts mocks base method.
func (m *MockClusterSnapshot) IsExistsHosts(metadata api.MetadataMatchCriteria) bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IsExistsHosts", metadata)
	ret0, _ := ret[0].(bool)
	return ret0
}

// IsExistsHosts indicates an expected call of IsExistsHosts.
func (mr *MockClusterSnapshotMockRecorder) IsExistsHosts(metadata interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsExistsHosts", reflect.TypeOf((*MockClusterSnapshot)(nil).IsExistsHosts), metadata)
}

// LoadBalancer mocks base method.
func (m *MockClusterSnapshot) LoadBalancer() types.LoadBalancer {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LoadBalancer")
	ret0, _ := ret[0].(types.LoadBalancer)
	return ret0
}

// LoadBalancer indicates an expected call of LoadBalancer.
func (mr *MockClusterSnapshotMockRecorder) LoadBalancer() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LoadBalancer", reflect.TypeOf((*MockClusterSnapshot)(nil).LoadBalancer))
}

// MockCluster is a mock of Cluster interface.
type MockCluster struct {
	ctrl     *gomock.Controller
	recorder *MockClusterMockRecorder
}

// MockClusterMockRecorder is the mock recorder for MockCluster.
type MockClusterMockRecorder struct {
	mock *MockCluster
}

// NewMockCluster creates a new mock instance.
func NewMockCluster(ctrl *gomock.Controller) *MockCluster {
	mock := &MockCluster{ctrl: ctrl}
	mock.recorder = &MockClusterMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockCluster) EXPECT() *MockClusterMockRecorder {
	return m.recorder
}

// AddHealthCheckCallbacks mocks base method.
func (m *MockCluster) AddHealthCheckCallbacks(cb types.HealthCheckCb) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "AddHealthCheckCallbacks", cb)
}

// AddHealthCheckCallbacks indicates an expected call of AddHealthCheckCallbacks.
func (mr *MockClusterMockRecorder) AddHealthCheckCallbacks(cb interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddHealthCheckCallbacks", reflect.TypeOf((*MockCluster)(nil).AddHealthCheckCallbacks), cb)
}

// Snapshot mocks base method.
func (m *MockCluster) Snapshot() types.ClusterSnapshot {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Snapshot")
	ret0, _ := ret[0].(types.ClusterSnapshot)
	return ret0
}

// Snapshot indicates an expected call of Snapshot.
func (mr *MockClusterMockRecorder) Snapshot() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Snapshot", reflect.TypeOf((*MockCluster)(nil).Snapshot))
}

// StopHealthChecking mocks base method.
func (m *MockCluster) StopHealthChecking() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "StopHealthChecking")
}

// StopHealthChecking indicates an expected call of StopHealthChecking.
func (mr *MockClusterMockRecorder) StopHealthChecking() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopHealthChecking", reflect.TypeOf((*MockCluster)(nil).StopHealthChecking))
}

// UpdateHosts mocks base method.
func (m *MockCluster) UpdateHosts(arg0 types.HostSet) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "UpdateHosts", arg0)
}

// UpdateHosts indicates an expected call of UpdateHosts.
func (mr *MockClusterMockRecorder) UpdateHosts(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateHosts", reflect.TypeOf((*MockCluster)(nil).UpdateHosts), arg0)
}

// MockHostSet is a mock of HostSet interface.
type MockHostSet struct {
	ctrl     *gomock.Controller
	recorder *MockHostSetMockRecorder
}

// MockHostSetMockRecorder is the mock recorder for MockHostSet.
type MockHostSetMockRecorder struct {
	mock *MockHostSet
}

// NewMockHostSet creates a new mock instance.
func NewMockHostSet(ctrl *gomock.Controller) *MockHostSet {
	mock := &MockHostSet{ctrl: ctrl}
	mock.recorder = &MockHostSetMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockHostSet) EXPECT() *MockHostSetMockRecorder {
	return m.recorder
}

// Get mocks base method.
func (m *MockHostSet) Get(i int) types.Host {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Get", i)
	ret0, _ := ret[0].(types.Host)
	return ret0
}

// Get indicates an expected call of Get.
func (mr *MockHostSetMockRecorder) Get(i interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockHostSet)(nil).Get), i)
}

// Range mocks base method.
func (m *MockHostSet) Range(arg0 func(types.Host) bool) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Range", arg0)
}

// Range indicates an expected call of Range.
func (mr *MockHostSetMockRecorder) Range(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Range", reflect.TypeOf((*MockHostSet)(nil).Range), arg0)
}

// Size mocks base method.
func (m *MockHostSet) Size() int {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Size")
	ret0, _ := ret[0].(int)
	return ret0
}

// Size indicates an expected call of Size.
func (mr *MockHostSetMockRecorder) Size() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Size", reflect.TypeOf((*MockHostSet)(nil).Size))
}

// MockHost is a mock of Host interface.
type MockHost struct {
	ctrl     *gomock.Controller
	recorder *MockHostMockRecorder
}

// MockHostMockRecorder is the mock recorder for MockHost.
type MockHostMockRecorder struct {
	mock *MockHost
}

// NewMockHost creates a new mock instance.
func NewMockHost(ctrl *gomock.Controller) *MockHost {
	mock := &MockHost{ctrl: ctrl}
	mock.recorder = &MockHostMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockHost) EXPECT() *MockHostMockRecorder {
	return m.recorder
}

// Address mocks base method.
func (m *MockHost) Address() net.Addr {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Address")
	ret0, _ := ret[0].(net.Addr)
	return ret0
}

// Address indicates an expected call of Address.
func (mr *MockHostMockRecorder) Address() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Address", reflect.TypeOf((*MockHost)(nil).Address))
}

// AddressString mocks base method.
func (m *MockHost) AddressString() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddressString")
	ret0, _ := ret[0].(string)
	return ret0
}

// AddressString indicates an expected call of AddressString.
func (mr *MockHostMockRecorder) AddressString() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddressString", reflect.TypeOf((*MockHost)(nil).AddressString))
}

// ClearHealthFlag mocks base method.
func (m *MockHost) ClearHealthFlag(flag api.HealthFlag) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "ClearHealthFlag", flag)
}

// ClearHealthFlag indicates an expected call of ClearHealthFlag.
func (mr *MockHostMockRecorder) ClearHealthFlag(flag interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClearHealthFlag", reflect.TypeOf((*MockHost)(nil).ClearHealthFlag), flag)
}

// ClusterInfo mocks base method.
func (m *MockHost) ClusterInfo() types.ClusterInfo {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ClusterInfo")
	ret0, _ := ret[0].(types.ClusterInfo)
	return ret0
}

// ClusterInfo indicates an expected call of ClusterInfo.
func (mr *MockHostMockRecorder) ClusterInfo() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterInfo", reflect.TypeOf((*MockHost)(nil).ClusterInfo))
}

// Config mocks base method.
func (m *MockHost) Config() v2.Host {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Config")
	ret0, _ := ret[0].(v2.Host)
	return ret0
}

// Config indicates an expected call of Config.
func (mr *MockHostMockRecorder) Config() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Config", reflect.TypeOf((*MockHost)(nil).Config))
}

// ContainHealthFlag mocks base method.
func (m *MockHost) ContainHealthFlag(flag api.HealthFlag) bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ContainHealthFlag", flag)
	ret0, _ := ret[0].(bool)
	return ret0
}

// ContainHealthFlag indicates an expected call of ContainHealthFlag.
func (mr *MockHostMockRecorder) ContainHealthFlag(flag interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContainHealthFlag", reflect.TypeOf((*MockHost)(nil).ContainHealthFlag), flag)
}

// CreateConnection mocks base method.
func (m *MockHost) CreateConnection(context context.Context) types.CreateConnectionData {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateConnection", context)
	ret0, _ := ret[0].(types.CreateConnectionData)
	return ret0
}

// CreateConnection indicates an expected call of CreateConnection.
func (mr *MockHostMockRecorder) CreateConnection(context interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateConnection", reflect.TypeOf((*MockHost)(nil).CreateConnection), context)
}

// CreateUDPConnection mocks base method.
func (m *MockHost) CreateUDPConnection(context context.Context) types.CreateConnectionData {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateUDPConnection", context)
	ret0, _ := ret[0].(types.CreateConnectionData)
	return ret0
}

// CreateUDPConnection indicates an expected call of CreateUDPConnection.
func (mr *MockHostMockRecorder) CreateUDPConnection(context interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateUDPConnection", reflect.TypeOf((*MockHost)(nil).CreateUDPConnection), context)
}

// Health mocks base method.
func (m *MockHost) Health() bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Health")
	ret0, _ := ret[0].(bool)
	return ret0
}

// Health indicates an expected call of Health.
func (mr *MockHostMockRecorder) Health() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Health", reflect.TypeOf((*MockHost)(nil).Health))
}

// HealthFlag mocks base method.
func (m *MockHost) HealthFlag() api.HealthFlag {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HealthFlag")
	ret0, _ := ret[0].(api.HealthFlag)
	return ret0
}

// HealthFlag indicates an expected call of HealthFlag.
func (mr *MockHostMockRecorder) HealthFlag() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HealthFlag", reflect.TypeOf((*MockHost)(nil).HealthFlag))
}

// HostStats mocks base method.
func (m *MockHost) HostStats() *types.HostStats {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HostStats")
	ret0, _ := ret[0].(*types.HostStats)
	return ret0
}

// HostStats indicates an expected call of HostStats.
func (mr *MockHostMockRecorder) HostStats() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HostStats", reflect.TypeOf((*MockHost)(nil).HostStats))
}

// Hostname mocks base method.
func (m *MockHost) Hostname() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Hostname")
	ret0, _ := ret[0].(string)
	return ret0
}

// Hostname indicates an expected call of Hostname.
func (mr *MockHostMockRecorder) Hostname() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Hostname", reflect.TypeOf((*MockHost)(nil).Hostname))
}

// LastHealthCheckPassTime mocks base method.
func (m *MockHost) LastHealthCheckPassTime() time.Time {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LastHealthCheckPassTime")
	ret0, _ := ret[0].(time.Time)
	return ret0
}

// LastHealthCheckPassTime indicates an expected call of LastHealthCheckPassTime.
func (mr *MockHostMockRecorder) LastHealthCheckPassTime() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LastHealthCheckPassTime", reflect.TypeOf((*MockHost)(nil).LastHealthCheckPassTime))
}

// Metadata mocks base method.
func (m *MockHost) Metadata() api.Metadata {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Metadata")
	ret0, _ := ret[0].(api.Metadata)
	return ret0
}

// Metadata indicates an expected call of Metadata.
func (mr *MockHostMockRecorder) Metadata() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Metadata", reflect.TypeOf((*MockHost)(nil).Metadata))
}

// SetClusterInfo mocks base method.
func (m *MockHost) SetClusterInfo(info types.ClusterInfo) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetClusterInfo", info)
}

// SetClusterInfo indicates an expected call of SetClusterInfo.
func (mr *MockHostMockRecorder) SetClusterInfo(info interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetClusterInfo", reflect.TypeOf((*MockHost)(nil).SetClusterInfo), info)
}

// SetHealthFlag mocks base method.
func (m *MockHost) SetHealthFlag(flag api.HealthFlag) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetHealthFlag", flag)
}

// SetHealthFlag indicates an expected call of SetHealthFlag.
func (mr *MockHostMockRecorder) SetHealthFlag(flag interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetHealthFlag", reflect.TypeOf((*MockHost)(nil).SetHealthFlag), flag)
}

// SetLastHealthCheckPassTime mocks base method.
func (m *MockHost) SetLastHealthCheckPassTime(lastHealthCheckPassTime time.Time) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetLastHealthCheckPassTime", lastHealthCheckPassTime)
}

// SetLastHealthCheckPassTime indicates an expected call of SetLastHealthCheckPassTime.
func (mr *MockHostMockRecorder) SetLastHealthCheckPassTime(lastHealthCheckPassTime interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLastHealthCheckPassTime", reflect.TypeOf((*MockHost)(nil).SetLastHealthCheckPassTime), lastHealthCheckPassTime)
}

// SupportTLS mocks base method.
func (m *MockHost) SupportTLS() bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SupportTLS")
	ret0, _ := ret[0].(bool)
	return ret0
}

// SupportTLS indicates an expected call of SupportTLS.
func (mr *MockHostMockRecorder) SupportTLS() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SupportTLS", reflect.TypeOf((*MockHost)(nil).SupportTLS))
}

// TLSHashValue mocks base method.
func (m *MockHost) TLSHashValue() *types.HashValue {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TLSHashValue")
	ret0, _ := ret[0].(*types.HashValue)
	return ret0
}

// TLSHashValue indicates an expected call of TLSHashValue.
func (mr *MockHostMockRecorder) TLSHashValue() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TLSHashValue", reflect.TypeOf((*MockHost)(nil).TLSHashValue))
}

// Weight mocks base method.
func (m *MockHost) Weight() uint32 {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Weight")
	ret0, _ := ret[0].(uint32)
	return ret0
}

// Weight indicates an expected call of Weight.
func (mr *MockHostMockRecorder) Weight() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Weight", reflect.TypeOf((*MockHost)(nil).Weight))
}

// MockClusterInfo is a mock of ClusterInfo interface.
type MockClusterInfo struct {
	ctrl     *gomock.Controller
	recorder *MockClusterInfoMockRecorder
}

// MockClusterInfoMockRecorder is the mock recorder for MockClusterInfo.
type MockClusterInfoMockRecorder struct {
	mock *MockClusterInfo
}

// NewMockClusterInfo creates a new mock instance.
func NewMockClusterInfo(ctrl *gomock.Controller) *MockClusterInfo {
	mock := &MockClusterInfo{ctrl: ctrl}
	mock.recorder = &MockClusterInfoMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockClusterInfo) EXPECT() *MockClusterInfoMockRecorder {
	return m.recorder
}

// ClusterType mocks base method.
func (m *MockClusterInfo) ClusterType() v2.ClusterType {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ClusterType")
	ret0, _ := ret[0].(v2.ClusterType)
	return ret0
}

// ClusterType indicates an expected call of ClusterType.
func (mr *MockClusterInfoMockRecorder) ClusterType() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterType", reflect.TypeOf((*MockClusterInfo)(nil).ClusterType))
}

// ConnBufferLimitBytes mocks base method.
func (m *MockClusterInfo) ConnBufferLimitBytes() uint32 {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ConnBufferLimitBytes")
	ret0, _ := ret[0].(uint32)
	return ret0
}

// ConnBufferLimitBytes indicates an expected call of ConnBufferLimitBytes.
func (mr *MockClusterInfoMockRecorder) ConnBufferLimitBytes() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConnBufferLimitBytes", reflect.TypeOf((*MockClusterInfo)(nil).ConnBufferLimitBytes))
}

// ConnectTimeout mocks base method.
func (m *MockClusterInfo) ConnectTimeout() time.Duration {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ConnectTimeout")
	ret0, _ := ret[0].(time.Duration)
	return ret0
}

// ConnectTimeout indicates an expected call of ConnectTimeout.
func (mr *MockClusterInfoMockRecorder) ConnectTimeout() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConnectTimeout", reflect.TypeOf((*MockClusterInfo)(nil).ConnectTimeout))
}

// IdleTimeout mocks base method.
func (m *MockClusterInfo) IdleTimeout() time.Duration {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IdleTimeout")
	ret0, _ := ret[0].(time.Duration)
	return ret0
}

// IdleTimeout indicates an expected call of IdleTimeout.
func (mr *MockClusterInfoMockRecorder) IdleTimeout() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IdleTimeout", reflect.TypeOf((*MockClusterInfo)(nil).IdleTimeout))
}

// IsClusterPoolEnable mocks base method.
func (m *MockClusterInfo) IsClusterPoolEnable() bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IsClusterPoolEnable")
	ret0, _ := ret[0].(bool)
	return ret0
}

// IsClusterPoolEnable indicates an expected call of IsClusterPoolEnable.
func (mr *MockClusterInfoMockRecorder) IsClusterPoolEnable() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsClusterPoolEnable", reflect.TypeOf((*MockClusterInfo)(nil).IsClusterPoolEnable))
}

// LbConfig mocks base method.
func (m *MockClusterInfo) LbConfig() *v2.LbConfig {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LbConfig")
	ret0, _ := ret[0].(*v2.LbConfig)
	return ret0
}

// LbConfig indicates an expected call of LbConfig.
func (mr *MockClusterInfoMockRecorder) LbConfig() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LbConfig", reflect.TypeOf((*MockClusterInfo)(nil).LbConfig))
}

// LbOriDstInfo mocks base method.
func (m *MockClusterInfo) LbOriDstInfo() types.LBOriDstInfo {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LbOriDstInfo")
	ret0, _ := ret[0].(types.LBOriDstInfo)
	return ret0
}

// LbOriDstInfo indicates an expected call of LbOriDstInfo.
func (mr *MockClusterInfoMockRecorder) LbOriDstInfo() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LbOriDstInfo", reflect.TypeOf((*MockClusterInfo)(nil).LbOriDstInfo))
}

// LbSubsetInfo mocks base method.
func (m *MockClusterInfo) LbSubsetInfo() types.LBSubsetInfo {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LbSubsetInfo")
	ret0, _ := ret[0].(types.LBSubsetInfo)
	return ret0
}

// LbSubsetInfo indicates an expected call of LbSubsetInfo.
func (mr *MockClusterInfoMockRecorder) LbSubsetInfo() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LbSubsetInfo", reflect.TypeOf((*MockClusterInfo)(nil).LbSubsetInfo))
}

// LbType mocks base method.
func (m *MockClusterInfo) LbType() types.LoadBalancerType {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LbType")
	ret0, _ := ret[0].(types.LoadBalancerType)
	return ret0
}

// LbType indicates an expected call of LbType.
func (mr *MockClusterInfoMockRecorder) LbType() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LbType", reflect.TypeOf((*MockClusterInfo)(nil).LbType))
}

// Mark mocks base method.
func (m *MockClusterInfo) Mark() uint32 {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Mark")
	ret0, _ := ret[0].(uint32)
	return ret0
}

// Mark indicates an expected call of Mark.
func (mr *MockClusterInfoMockRecorder) Mark() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Mark", reflect.TypeOf((*MockClusterInfo)(nil).Mark))
}

// MaxRequestsPerConn mocks base method.
func (m *MockClusterInfo) MaxRequestsPerConn() uint32 {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "MaxRequestsPerConn")
	ret0, _ := ret[0].(uint32)
	return ret0
}

// MaxRequestsPerConn indicates an expected call of MaxRequestsPerConn.
func (mr *MockClusterInfoMockRecorder) MaxRequestsPerConn() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MaxRequestsPerConn", reflect.TypeOf((*MockClusterInfo)(nil).MaxRequestsPerConn))
}

// Name mocks base method.
func (m *MockClusterInfo) Name() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Name")
	ret0, _ := ret[0].(string)
	return ret0
}

// Name indicates an expected call of Name.
func (mr *MockClusterInfoMockRecorder) Name() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Name", reflect.TypeOf((*MockClusterInfo)(nil).Name))
}

// ResourceManager mocks base method.
func (m *MockClusterInfo) ResourceManager() types.ResourceManager {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ResourceManager")
	ret0, _ := ret[0].(types.ResourceManager)
	return ret0
}

// ResourceManager indicates an expected call of ResourceManager.
func (mr *MockClusterInfoMockRecorder) ResourceManager() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResourceManager", reflect.TypeOf((*MockClusterInfo)(nil).ResourceManager))
}

// SlowStart mocks base method.
func (m *MockClusterInfo) SlowStart() types.SlowStart {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SlowStart")
	ret0, _ := ret[0].(types.SlowStart)
	return ret0
}

// SlowStart indicates an expected call of SlowStart.
func (mr *MockClusterInfoMockRecorder) SlowStart() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SlowStart", reflect.TypeOf((*MockClusterInfo)(nil).SlowStart))
}

// Stats mocks base method.
func (m *MockClusterInfo) Stats() *types.ClusterStats {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Stats")
	ret0, _ := ret[0].(*types.ClusterStats)
	return ret0
}

// Stats indicates an expected call of Stats.
func (mr *MockClusterInfoMockRecorder) Stats() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Stats", reflect.TypeOf((*MockClusterInfo)(nil).Stats))
}

// SubType mocks base method.
func (m *MockClusterInfo) SubType() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SubType")
	ret0, _ := ret[0].(string)
	return ret0
}

// SubType indicates an expected call of SubType.
func (mr *MockClusterInfoMockRecorder) SubType() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubType", reflect.TypeOf((*MockClusterInfo)(nil).SubType))
}

// TLSMng mocks base method.
func (m *MockClusterInfo) TLSMng() types.TLSClientContextManager {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TLSMng")
	ret0, _ := ret[0].(types.TLSClientContextManager)
	return ret0
}

// TLSMng indicates an expected call of TLSMng.
func (mr *MockClusterInfoMockRecorder) TLSMng() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TLSMng", reflect.TypeOf((*MockClusterInfo)(nil).TLSMng))
}

// MockResourceManager is a mock of ResourceManager interface.
type MockResourceManager struct {
	ctrl     *gomock.Controller
	recorder *MockResourceManagerMockRecorder
}

// MockResourceManagerMockRecorder is the mock recorder for MockResourceManager.
type MockResourceManagerMockRecorder struct {
	mock *MockResourceManager
}

// NewMockResourceManager creates a new mock instance.
func NewMockResourceManager(ctrl *gomock.Controller) *MockResourceManager {
	mock := &MockResourceManager{ctrl: ctrl}
	mock.recorder = &MockResourceManagerMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockResourceManager) EXPECT() *MockResourceManagerMockRecorder {
	return m.recorder
}

// Connections mocks base method.
func (m *MockResourceManager) Connections() types.Resource {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Connections")
	ret0, _ := ret[0].(types.Resource)
	return ret0
}

// Connections indicates an expected call of Connections.
func (mr *MockResourceManagerMockRecorder) Connections() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Connections", reflect.TypeOf((*MockResourceManager)(nil).Connections))
}

// PendingRequests mocks base method.
func (m *MockResourceManager) PendingRequests() types.Resource {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PendingRequests")
	ret0, _ := ret[0].(types.Resource)
	return ret0
}

// PendingRequests indicates an expected call of PendingRequests.
func (mr *MockResourceManagerMockRecorder) PendingRequests() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PendingRequests", reflect.TypeOf((*MockResourceManager)(nil).PendingRequests))
}

// Requests mocks base method.
func (m *MockResourceManager) Requests() types.Resource {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Requests")
	ret0, _ := ret[0].(types.Resource)
	return ret0
}

// Requests indicates an expected call of Requests.
func (mr *MockResourceManagerMockRecorder) Requests() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Requests", reflect.TypeOf((*MockResourceManager)(nil).Requests))
}

// Retries mocks base method.
func (m *MockResourceManager) Retries() types.Resource {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Retries")
	ret0, _ := ret[0].(types.Resource)
	return ret0
}

// Retries indicates an expected call of Retries.
func (mr *MockResourceManagerMockRecorder) Retries() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Retries", reflect.TypeOf((*MockResourceManager)(nil).Retries))
}

// MockResource is a mock of Resource interface.
type MockResource struct {
	ctrl     *gomock.Controller
	recorder *MockResourceMockRecorder
}

// MockResourceMockRecorder is the mock recorder for MockResource.
type MockResourceMockRecorder struct {
	mock *MockResource
}

// NewMockResource creates a new mock instance.
func NewMockResource(ctrl *gomock.Controller) *MockResource {
	mock := &MockResource{ctrl: ctrl}
	mock.recorder = &MockResourceMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockResource) EXPECT() *MockResourceMockRecorder {
	return m.recorder
}

// CanCreate mocks base method.
func (m *MockResource) CanCreate() bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CanCreate")
	ret0, _ := ret[0].(bool)
	return ret0
}

// CanCreate indicates an expected call of CanCreate.
func (mr *MockResourceMockRecorder) CanCreate() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CanCreate", reflect.TypeOf((*MockResource)(nil).CanCreate))
}

// Cur mocks base method.
func (m *MockResource) Cur() int64 {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Cur")
	ret0, _ := ret[0].(int64)
	return ret0
}

// Cur indicates an expected call of Cur.
func (mr *MockResourceMockRecorder) Cur() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Cur", reflect.TypeOf((*MockResource)(nil).Cur))
}

// Decrease mocks base method.
func (m *MockResource) Decrease() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Decrease")
}

// Decrease indicates an expected call of Decrease.
func (mr *MockResourceMockRecorder) Decrease() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Decrease", reflect.TypeOf((*MockResource)(nil).Decrease))
}

// Increase mocks base method.
func (m *MockResource) Increase() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Increase")
}

// Increase indicates an expected call of Increase.
func (mr *MockResourceMockRecorder) Increase() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Increase", reflect.TypeOf((*MockResource)(nil).Increase))
}

// Max mocks base method.
func (m *MockResource) Max() uint64 {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Max")
	ret0, _ := ret[0].(uint64)
	return ret0
}

// Max indicates an expected call of Max.
func (mr *MockResourceMockRecorder) Max() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Max", reflect.TypeOf((*MockResource)(nil).Max))
}

// UpdateCur mocks base method.
func (m *MockResource) UpdateCur(arg0 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "UpdateCur", arg0)
}

// UpdateCur indicates an expected call of UpdateCur.
func (mr *MockResourceMockRecorder) UpdateCur(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateCur", reflect.TypeOf((*MockResource)(nil).UpdateCur), arg0)
}

// MockSimpleCluster is a mock of SimpleCluster interface.
type MockSimpleCluster struct {
	ctrl     *gomock.Controller
	recorder *MockSimpleClusterMockRecorder
}

// MockSimpleClusterMockRecorder is the mock recorder for MockSimpleCluster.
type MockSimpleClusterMockRecorder struct {
	mock *MockSimpleCluster
}

// NewMockSimpleCluster creates a new mock instance.
func NewMockSimpleCluster(ctrl *gomock.Controller) *MockSimpleCluster {
	mock := &MockSimpleCluster{ctrl: ctrl}
	mock.recorder = &MockSimpleClusterMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockSimpleCluster) EXPECT() *MockSimpleClusterMockRecorder {
	return m.recorder
}

// UpdateHosts mocks base method.
func (m *MockSimpleCluster) UpdateHosts(newHosts []types.Host) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "UpdateHosts", newHosts)
}

// UpdateHosts indicates an expected call of UpdateHosts.
func (mr *MockSimpleClusterMockRecorder) UpdateHosts(newHosts interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateHosts", reflect.TypeOf((*MockSimpleCluster)(nil).UpdateHosts), newHosts)
}

// MockClusterConfigFactoryCb is a mock of ClusterConfigFactoryCb interface.
type MockClusterConfigFactoryCb struct {
	ctrl     *gomock.Controller
	recorder *MockClusterConfigFactoryCbMockRecorder
}

// MockClusterConfigFactoryCbMockRecorder is the mock recorder for MockClusterConfigFactoryCb.
type MockClusterConfigFactoryCbMockRecorder struct {
	mock *MockClusterConfigFactoryCb
}

// NewMockClusterConfigFactoryCb creates a new mock instance.
func NewMockClusterConfigFactoryCb(ctrl *gomock.Controller) *MockClusterConfigFactoryCb {
	mock := &MockClusterConfigFactoryCb{ctrl: ctrl}
	mock.recorder = &MockClusterConfigFactoryCbMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockClusterConfigFactoryCb) EXPECT() *MockClusterConfigFactoryCbMockRecorder {
	return m.recorder
}

// UpdateClusterConfig mocks base method.
func (m *MockClusterConfigFactoryCb) UpdateClusterConfig(configs []v2.Cluster) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateClusterConfig", configs)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateClusterConfig indicates an expected call of UpdateClusterConfig.
func (mr *MockClusterConfigFactoryCbMockRecorder) UpdateClusterConfig(configs interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateClusterConfig", reflect.TypeOf((*MockClusterConfigFactoryCb)(nil).UpdateClusterConfig), configs)
}

// MockClusterHostFactoryCb is a mock of ClusterHostFactoryCb interface.
type MockClusterHostFactoryCb struct {
	ctrl     *gomock.Controller
	recorder *MockClusterHostFactoryCbMockRecorder
}

// MockClusterHostFactoryCbMockRecorder is the mock recorder for MockClusterHostFactoryCb.
type MockClusterHostFactoryCbMockRecorder struct {
	mock *MockClusterHostFactoryCb
}

// NewMockClusterHostFactoryCb creates a new mock instance.
func NewMockClusterHostFactoryCb(ctrl *gomock.Controller) *MockClusterHostFactoryCb {
	mock := &MockClusterHostFactoryCb{ctrl: ctrl}
	mock.recorder = &MockClusterHostFactoryCbMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockClusterHostFactoryCb) EXPECT() *MockClusterHostFactoryCbMockRecorder {
	return m.recorder
}

// UpdateClusterHost mocks base method.
func (m *MockClusterHostFactoryCb) UpdateClusterHost(cluster string, hosts []v2.Host) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateClusterHost", cluster, hosts)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateClusterHost indicates an expected call of UpdateClusterHost.
func (mr *MockClusterHostFactoryCbMockRecorder) UpdateClusterHost(cluster, hosts interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateClusterHost", reflect.TypeOf((*MockClusterHostFactoryCb)(nil).UpdateClusterHost), cluster, hosts)
}

// MockClusterManagerFilter is a mock of ClusterManagerFilter interface.
type MockClusterManagerFilter struct {
	ctrl     *gomock.Controller
	recorder *MockClusterManagerFilterMockRecorder
}

// MockClusterManagerFilterMockRecorder is the mock recorder for MockClusterManagerFilter.
type MockClusterManagerFilterMockRecorder struct {
	mock *MockClusterManagerFilter
}

// NewMockClusterManagerFilter creates a new mock instance.
func NewMockClusterManagerFilter(ctrl *gomock.Controller) *MockClusterManagerFilter {
	mock := &MockClusterManagerFilter{ctrl: ctrl}
	mock.recorder = &MockClusterManagerFilterMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockClusterManagerFilter) EXPECT() *MockClusterManagerFilterMockRecorder {
	return m.recorder
}

// OnCreated mocks base method.
func (m *MockClusterManagerFilter) OnCreated(cccb types.ClusterConfigFactoryCb, chcb types.ClusterHostFactoryCb) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "OnCreated", cccb, chcb)
}

// OnCreated indicates an expected call of OnCreated.
func (mr *MockClusterManagerFilterMockRecorder) OnCreated(cccb, chcb interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OnCreated", reflect.TypeOf((*MockClusterManagerFilter)(nil).OnCreated), cccb, chcb)
}

// MockRegisterUpstreamUpdateMethodCb is a mock of RegisterUpstreamUpdateMethodCb interface.
type MockRegisterUpstreamUpdateMethodCb struct {
	ctrl     *gomock.Controller
	recorder *MockRegisterUpstreamUpdateMethodCbMockRecorder
}

// MockRegisterUpstreamUpdateMethodCbMockRecorder is the mock recorder for MockRegisterUpstreamUpdateMethodCb.
type MockRegisterUpstreamUpdateMethodCbMockRecorder struct {
	mock *MockRegisterUpstreamUpdateMethodCb
}

// NewMockRegisterUpstreamUpdateMethodCb creates a new mock instance.
func NewMockRegisterUpstreamUpdateMethodCb(ctrl *gomock.Controller) *MockRegisterUpstreamUpdateMethodCb {
	mock := &MockRegisterUpstreamUpdateMethodCb{ctrl: ctrl}
	mock.recorder = &MockRegisterUpstreamUpdateMethodCbMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockRegisterUpstreamUpdateMethodCb) EXPECT() *MockRegisterUpstreamUpdateMethodCbMockRecorder {
	return m.recorder
}

// GetClusterNameByServiceName mocks base method.
func (m *MockRegisterUpstreamUpdateMethodCb) GetClusterNameByServiceName(serviceName string) string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetClusterNameByServiceName", serviceName)
	ret0, _ := ret[0].(string)
	return ret0
}

// GetClusterNameByServiceName indicates an expected call of GetClusterNameByServiceName.
func (mr *MockRegisterUpstreamUpdateMethodCbMockRecorder) GetClusterNameByServiceName(serviceName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetClusterNameByServiceName", reflect.TypeOf((*MockRegisterUpstreamUpdateMethodCb)(nil).GetClusterNameByServiceName), serviceName)
}

// TriggerClusterUpdate mocks base method.
func (m *MockRegisterUpstreamUpdateMethodCb) TriggerClusterUpdate(clusterName string, hosts []v2.Host) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "TriggerClusterUpdate", clusterName, hosts)
}

// TriggerClusterUpdate indicates an expected call of TriggerClusterUpdate.
func (mr *MockRegisterUpstreamUpdateMethodCbMockRecorder) TriggerClusterUpdate(clusterName, hosts interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TriggerClusterUpdate", reflect.TypeOf((*MockRegisterUpstreamUpdateMethodCb)(nil).TriggerClusterUpdate), clusterName, hosts)
}

// MockLBSubsetInfo is a mock of LBSubsetInfo interface.
type MockLBSubsetInfo struct {
	ctrl     *gomock.Controller
	recorder *MockLBSubsetInfoMockRecorder
}

// MockLBSubsetInfoMockRecorder is the mock recorder for MockLBSubsetInfo.
type MockLBSubsetInfoMockRecorder struct {
	mock *MockLBSubsetInfo
}

// NewMockLBSubsetInfo creates a new mock instance.
func NewMockLBSubsetInfo(ctrl *gomock.Controller) *MockLBSubsetInfo {
	mock := &MockLBSubsetInfo{ctrl: ctrl}
	mock.recorder = &MockLBSubsetInfoMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockLBSubsetInfo) EXPECT() *MockLBSubsetInfoMockRecorder {
	return m.recorder
}

// DefaultSubset mocks base method.
func (m *MockLBSubsetInfo) DefaultSubset() types.SubsetMetadata {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DefaultSubset")
	ret0, _ := ret[0].(types.SubsetMetadata)
	return ret0
}

// DefaultSubset indicates an expected call of DefaultSubset.
func (mr *MockLBSubsetInfoMockRecorder) DefaultSubset() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DefaultSubset", reflect.TypeOf((*MockLBSubsetInfo)(nil).DefaultSubset))
}

// FallbackPolicy mocks base method.
func (m *MockLBSubsetInfo) FallbackPolicy() types.FallBackPolicy {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FallbackPolicy")
	ret0, _ := ret[0].(types.FallBackPolicy)
	return ret0
}

// FallbackPolicy indicates an expected call of FallbackPolicy.
func (mr *MockLBSubsetInfoMockRecorder) FallbackPolicy() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FallbackPolicy", reflect.TypeOf((*MockLBSubsetInfo)(nil).FallbackPolicy))
}

// IsEnabled mocks base method.
func (m *MockLBSubsetInfo) IsEnabled() bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IsEnabled")
	ret0, _ := ret[0].(bool)
	return ret0
}

// IsEnabled indicates an expected call of IsEnabled.
func (mr *MockLBSubsetInfoMockRecorder) IsEnabled() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsEnabled", reflect.TypeOf((*MockLBSubsetInfo)(nil).IsEnabled))
}

// SubsetKeys mocks base method.
func (m *MockLBSubsetInfo) SubsetKeys() []types.SortedStringSetType {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SubsetKeys")
	ret0, _ := ret[0].([]types.SortedStringSetType)
	return ret0
}

// SubsetKeys indicates an expected call of SubsetKeys.
func (mr *MockLBSubsetInfoMockRecorder) SubsetKeys() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubsetKeys", reflect.TypeOf((*MockLBSubsetInfo)(nil).SubsetKeys))
}

// MockLBOriDstInfo is a mock of LBOriDstInfo interface.
type MockLBOriDstInfo struct {
	ctrl     *gomock.Controller
	recorder *MockLBOriDstInfoMockRecorder
}

// MockLBOriDstInfoMockRecorder is the mock recorder for MockLBOriDstInfo.
type MockLBOriDstInfoMockRecorder struct {
	mock *MockLBOriDstInfo
}

// NewMockLBOriDstInfo creates a new mock instance.
func NewMockLBOriDstInfo(ctrl *gomock.Controller) *MockLBOriDstInfo {
	mock := &MockLBOriDstInfo{ctrl: ctrl}
	mock.recorder = &MockLBOriDstInfoMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockLBOriDstInfo) EXPECT() *MockLBOriDstInfoMockRecorder {
	return m.recorder
}

// GetHeader mocks base method.
func (m *MockLBOriDstInfo) GetHeader() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetHeader")
	ret0, _ := ret[0].(string)
	return ret0
}

// GetHeader indicates an expected call of GetHeader.
func (mr *MockLBOriDstInfoMockRecorder) GetHeader() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHeader", reflect.TypeOf((*MockLBOriDstInfo)(nil).GetHeader))
}

// IsEnabled mocks base method.
func (m *MockLBOriDstInfo) IsEnabled() bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IsEnabled")
	ret0, _ := ret[0].(bool)
	return ret0
}

// IsEnabled indicates an expected call of IsEnabled.
func (mr *MockLBOriDstInfoMockRecorder) IsEnabled() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsEnabled", reflect.TypeOf((*MockLBOriDstInfo)(nil).IsEnabled))
}

// IsReplaceLocal mocks base method.
func (m *MockLBOriDstInfo) IsReplaceLocal() bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IsReplaceLocal")
	ret0, _ := ret[0].(bool)
	return ret0
}

// IsReplaceLocal indicates an expected call of IsReplaceLocal.
func (mr *MockLBOriDstInfoMockRecorder) IsReplaceLocal() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsReplaceLocal", reflect.TypeOf((*MockLBOriDstInfo)(nil).IsReplaceLocal))
}
